home *** CD-ROM | disk | FTP | other *** search
/ .net 2002 March / DotNetMagazine-Issue107-Coverdisc-NET107-02-03-PCMac.bin / pc / PC Software / picks / HTTrack / httrack-3.22-3.exe / {app} / src_win / WinHTTrack / newlang.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  2002-10-30  |  12.3 KB  |  473 lines
  1.  
  2. // Win includes
  3. #include "stdafx.h"
  4. #include "Shell.h"
  5.  
  6. // Hash for lang.h
  7. extern "C" {
  8.   #include "htsinthash.h"
  9.   #include "HTTrackInterface.h"
  10. };
  11. #include "newlang.h"
  12.  
  13. // test
  14. #ifndef _MBCS
  15. #error "MBCS/DBCS support not found"
  16. #endif
  17. #include <locale.h>
  18.  
  19.  
  20. int NewLangStrSz=1024;
  21. inthash NewLangStr=NULL;
  22. int NewLangStrKeysSz=1024;
  23. inthash NewLangStrKeys=NULL;
  24.  
  25.  
  26. void LANG_LOAD(char* limit_to) {
  27.   CWaitCursor wait;
  28.   //
  29.   extern int NewLangStrSz;
  30.   extern inthash NewLangStr;
  31.   extern int NewLangStrKeysSz;
  32.   extern inthash NewLangStrKeys;
  33.   //
  34.   int selected_lang=LANG_T(-1);
  35.   //
  36.   if (!limit_to) {
  37.     LANG_DELETE();
  38.     NewLangStr=inthash_new(NewLangStrSz);
  39.     NewLangStrKeys=inthash_new(NewLangStrKeysSz);
  40.     if ((NewLangStr==NULL) || (NewLangStrKeys==NULL)) {
  41.       AfxMessageBox("Error in lang.h: not enough memory");
  42.     } else {
  43.       inthash_value_is_malloc(NewLangStr,1);
  44.       inthash_value_is_malloc(NewLangStrKeys,1);
  45.     }
  46.   }
  47.  
  48.   CString app;
  49.   CWinApp* pApp = AfxGetApp();
  50.   if (pApp) {
  51.     app=pApp->m_pszHelpFilePath;
  52.     app=app.Left(app.ReverseFind('\\')+1);
  53.   }
  54.  
  55.   /* Load master file (list of keys and internal keys) */
  56.   if (!limit_to) {
  57.     CString mname=app+"lang.def";
  58.     if (!fexist((char*)LPCTSTR(mname)))
  59.       mname="lang.def";
  60.     FILE* fp=fopen(mname,"rb");
  61.     if (fp) {
  62.       char intkey[8192];
  63.       char key[8192];
  64.       while(!feof(fp)) {
  65.         linput_cpp(fp,intkey,8000);
  66.         linput_cpp(fp,key,8000);
  67.         if (strnotempty(intkey) && strnotempty(key)) {
  68.           char* test=LANGINTKEY(key);
  69.  
  70.           /* Increment for multiple definitions */
  71.           if (strnotempty(test)) {
  72.             int increment=0;
  73.             int pos=strlen(key);
  74.             do {
  75.               increment++;
  76.               sprintf(key+pos,"%d",increment);
  77.               test=LANGINTKEY(key);
  78.             }  while (strnotempty(test));
  79.           }
  80.  
  81.           if (!strnotempty(test)) {         // Èviter doublons
  82.             // conv_printf(key,key);
  83.             int len;
  84.             char* buff;
  85.             len=strlen(intkey);
  86.             buff=(char*)malloc(len+2);
  87.             if (buff) {
  88.               strcpybuff(buff,intkey);
  89.               inthash_add(NewLangStrKeys,key,(long int)(char*)buff);
  90.             }
  91.           }
  92.         } // if
  93.       }  // while
  94.       fclose(fp);
  95.     } else {
  96.       AfxMessageBox("FATAL ERROR\r\n'lang.def' file NOT FOUND!\r\nEnsure that the installation was complete!");
  97.       exit(0);
  98.     }
  99.   }
  100.   
  101.   /* Language Name? */
  102.   char* hashname;
  103.   {
  104.     char name[256];
  105.     sprintf(name,"LANGUAGE_%d",selected_lang+1);
  106.     hashname=LANGINTKEY(name);
  107.   }
  108.  
  109.   /* Get only language name */
  110.   if (limit_to) {
  111.     if (hashname)
  112.       strcpybuff(limit_to,hashname);
  113.     else
  114.       strcpybuff(limit_to,"???");
  115.     return;
  116.   }
  117.  
  118.   /* Error */
  119.   if (!hashname)
  120.     return;
  121.  
  122.   // xxc TEST
  123.   /*
  124.   setlocale( LC_ALL, "Japanese");
  125.   _setmbcp(932);    // shift-jis
  126.   setlocale( LC_ALL, ".932" );
  127.   setlocale( LC_ALL, "[.932]" );
  128.   CString st="";
  129.   int lid=SetThreadLocale(MAKELCID(MAKELANGID(LANG_JAPANESE,SUBLANG_NEUTRAL),SORT_DEFAULT ));
  130.   */
  131.  
  132.   /* Load specific language file */
  133.   {
  134.     int loops;
  135.     CString err_msg="";
  136.     // 2nd loop: load undefined strings
  137.     for(loops=0;loops<2;loops++) {
  138.       CString lbasename;
  139.       
  140.       {
  141.         char name[256];
  142.         sprintf(name,"LANGUAGE_%d",(loops==0)?(selected_lang+1):1);
  143.         hashname=LANGINTKEY(name);
  144.       }
  145.       lbasename.Format("lang/%s.txt",hashname);
  146.       CString lname=app+lbasename;
  147.       if (!fexist((char*)LPCTSTR(lname)))
  148.         lname=lbasename;
  149.       FILE* fp=fopen(lname,"rb");
  150.       if (fp) {
  151.         char extkey[8192];
  152.         TCHAR value[8192];
  153.         while(!feof(fp)) {
  154.           //int ssz;
  155.           linput_cpp(fp,extkey,8000);
  156.           linput_cpp(fp,value,8000);
  157.           /*
  158.           ssz=linput_cpp(fp,value,8000);
  159.           CString st=value;
  160.           AfxMessageBox(st);
  161.           if (ssz>0) {
  162.             int tst=0;
  163.             int test=IsTextUnicode(value,ssz,&tst);
  164.             unsigned short st2[1024];
  165.             int ret=MultiByteToWideChar(CP_UTF8,0,(char*)value,ssz,st2,1024);
  166.             if (ret>0) {
  167.               char st3[1024]="";
  168.               int ret2=WideCharToMultiByte(CP_THREAD_ACP,0,st2,ret,(char*)st3,1024,NULL,FALSE);
  169.               if (ret2>0) {
  170.                 AfxMessageBox(st3);
  171.               }
  172.             }
  173.           }
  174.           */
  175.  
  176.           if (strnotempty(extkey) && strnotempty(value)) {
  177.             int len;
  178.             char* buff;
  179.             char* intkey;
  180.             
  181.             intkey=LANGINTKEY(extkey);
  182.             
  183.             if (strnotempty(intkey)) {
  184.               
  185.               /* Increment for multiple definitions */
  186.               {
  187.                 char* test=LANGSEL(intkey);
  188.                 if (strnotempty(test)) {
  189.                   if (loops == 0) {
  190.                     int increment=0;
  191.                     int pos=strlen(extkey);
  192.                     do {
  193.                       increment++;
  194.                       sprintf(extkey+pos,"%d",increment);
  195.                       intkey=LANGINTKEY(extkey);
  196.                       if (strnotempty(intkey))
  197.                         test=LANGSEL(intkey);
  198.                       else
  199.                         test="";
  200.                     }  while (strnotempty(test));
  201.                   } else
  202.                     intkey="";
  203.                 } else {
  204.                   if (loops > 0) {
  205.                     err_msg += intkey;
  206.                     err_msg += " ";
  207.                   }
  208.                 }
  209.               }
  210.               
  211.               /* Add key */
  212.               if (strnotempty(intkey)) {
  213.                 len=strlen(value);
  214.                 buff=(char*)malloc(len+2);
  215.                 if (buff) {
  216.                   conv_printf(value,buff);
  217.                   inthash_add(NewLangStr,intkey,(long int)(char*)buff);
  218.                 }
  219.               }
  220.               
  221.             }
  222.           } // if
  223.         }  // while
  224.         fclose(fp);
  225.       } else {
  226.         AfxMessageBox("FATAL ERROR\r\n'lang.def' file NOT FOUND!\r\nEnsure that the installation was complete!");
  227.         exit(0);
  228.       }
  229.     }
  230.     if (err_msg.GetLength()>0) {
  231.       // AfxMessageBox("Error: undefined strings follows:\r\n"+err_msg);
  232.     }
  233.   }
  234.  
  235.  
  236.  
  237. #if 0
  238.   app=app+"lang.h";
  239.   if (!fexist((char*)LPCTSTR(app)))
  240.     app="lang.h";
  241.   
  242.   FILE* fp=fopen(app,"rb");
  243.   if (fp) {
  244.     char s[8192];
  245.     while(!feof(fp)) {
  246.       linput_cpp(fp,s,8000);
  247.       if (!strncmp(s,"#define ",8)) {
  248.         char* a;
  249.         char* name=s+8;
  250.         a=name;
  251.         while((*a!=' ') && (*a)) a++;
  252.         if ((*a) && (strlen(name)>0) && (((int) a - (int) name)<64)) {
  253.           *a++='\0';
  254.           if (limit_to) {
  255.             if (strcmp(name,limit_to))
  256.               a=NULL;
  257.           }
  258.           if (a) {
  259.             char* data;
  260.             data=a;
  261.             int toggle=0;
  262.             char* start_str=NULL;
  263.             int count=0;
  264.             while(*a) {
  265.               if (*a=='\"') {
  266.                 toggle++;
  267.                 if ((toggle%2)==1) {
  268.                   if (count==selected_lang) {
  269.                     start_str=a+1;
  270.                   }
  271.                   count++;
  272.                 } else {
  273.                   if (start_str) {
  274.                     char* buff;
  275.                     int len;
  276.                     len=(int) a - (int) start_str;
  277.                     if (len) {
  278.                       buff=(char*)malloc(len+2);
  279.                       if (buff) {
  280.                         int i=0,j=0;
  281.                         buff[0]='\0';
  282.                         //strncatbuff(buff,start_str,len);
  283.                         while(i<len) {
  284.                           switch(start_str[i]) {
  285.                           case '\\': 
  286.                             i++;
  287.                             switch(start_str[i]) {
  288.                             case 'a': buff[j]='\a'; break;
  289.                             case 'b': buff[j]='\b'; break;
  290.                             case 'f': buff[j]='\f'; break;
  291.                             case 'n': buff[j]='\n'; break;
  292.                             case 'r': buff[j]='\r'; break;
  293.                             case 't': buff[j]='\t'; break;
  294.                             case 'v': buff[j]='\v'; break;
  295.                             case '\'': buff[j]='\''; break;
  296.                             case '\"': buff[j]='\"'; break;
  297.                             case '\\': buff[j]='\\'; break;
  298.                             case '?': buff[j]='\?'; break;
  299.                             default: buff[j]=start_str[i]; break;
  300.                             }
  301.                             break;
  302.                             default: 
  303.                               buff[j]=start_str[i]; 
  304.                               break;
  305.                           }
  306.                           i++;
  307.                           j++;
  308.                         }
  309.                         buff[j++]='\0';
  310.                         if (!limit_to)
  311.                           inthash_add(NewLangStr,name,(long int)(char*)buff);
  312.                         else {
  313.                           strcpybuff(limit_to,buff);
  314.                           free(buff);
  315.                           return;
  316.                         }
  317.                       }
  318.                     }
  319.                     start_str=NULL;
  320.                   }
  321.                 }
  322.               }
  323.               a++;
  324.             }
  325.           }
  326.           
  327.           //NewLangStr.SetAt(sname,st);
  328.           /*
  329.           } else {
  330.           CString info;
  331.           info.Format("Error in lang.h: %s",name);
  332.           AfxMessageBox(info);
  333.         */
  334.         }
  335.       }
  336.     }
  337.  
  338.  
  339.     fclose(fp);
  340.  
  341.   } else {
  342.     AfxMessageBox("FATAL ERROR\r\n'lang.h' file NOT FOUND!\r\nEnsure that the installation was complete!");
  343.     exit(0);
  344.   }
  345. #endif
  346.  
  347.   // Control limit_to
  348.   if (limit_to)
  349.     limit_to[0]='\0';
  350. }
  351.  
  352. void conv_printf(char* from,char* to) {
  353.   int i=0,j=0,len;
  354.   len=strlen(from);
  355.   while(i<len) {
  356.     switch(from[i]) {
  357.     case '\\': 
  358.       i++;
  359.       switch(from[i]) {
  360.       case 'a': to[j]='\a'; break;
  361.       case 'b': to[j]='\b'; break;
  362.       case 'f': to[j]='\f'; break;
  363.       case 'n': to[j]='\n'; break;
  364.       case 'r': to[j]='\r'; break;
  365.       case 't': to[j]='\t'; break;
  366.       case 'v': to[j]='\v'; break;
  367.       case '\'': to[j]='\''; break;
  368.       case '\"': to[j]='\"'; break;
  369.       case '\\': to[j]='\\'; break;
  370.       case '?': to[j]='\?'; break;
  371.       default: to[j]=from[i]; break;
  372.       }
  373.       break;
  374.       default: 
  375.         to[j]=from[i]; 
  376.         break;
  377.     }
  378.     i++;
  379.     j++;
  380.   }
  381.   to[j++]='\0';
  382. }
  383.  
  384. void LANG_DELETE() {
  385.   extern int NewLangStrSz;
  386.   extern inthash NewLangStr;
  387.   extern int NewLangStrKeysSz;
  388.   extern inthash NewLangStrKeys;
  389.   //
  390.   inthash_delete(&NewLangStr);
  391.   inthash_delete(&NewLangStrKeys);
  392. }
  393.  
  394. // sÈlection de la langue
  395. void LANG_INIT() {
  396.   CWinApp* pApp = AfxGetApp();
  397.   if (pApp) {
  398.     int test = pApp->GetProfileInt("Language","IntId",0);
  399.     LANG_T(pApp->GetProfileInt("Language","IntId",0));
  400.   }
  401. }
  402.  
  403. int LANG_T(int l) {
  404.   if (l>=0) {
  405.     QLANG_T(l);
  406.     CWinApp* pApp = AfxGetApp();
  407.     if (pApp)
  408.       pApp->WriteProfileInt("Language","IntId",l);
  409.     LANG_LOAD(NULL);
  410.   }
  411.   return QLANG_T(-1);  // 0=default (english)
  412. }
  413.  
  414. int QLANG_T(int l) {
  415.   static int lng=0;
  416.   if (l>=0) {
  417.     lng=l;
  418.   }
  419.   return lng;  // 0=default (english)
  420. }
  421.  
  422.  
  423. /*
  424. char* LANGSEL(char* lang0,...) {
  425.   char* lang=lang0;
  426.   char* langalt="";
  427.   int langid=LANG_T(-1);
  428.   //
  429.   va_list argList;
  430.     va_start(argList, lang0);
  431.   while(langid>0) {
  432.     if (lang) {
  433.       if (strlen(langalt)==0) {
  434.         if (strlen(lang)>0)
  435.           langalt=lang;
  436.       }
  437.     }
  438.     langid--;
  439.     lang=va_arg(argList, char*);
  440.   }
  441.   va_end(argList);
  442.   //
  443.   if (!lang)
  444.     return langalt;
  445.   if (strlen(lang)==0)
  446.     return langalt;
  447.   return lang;
  448. }
  449. */
  450.  
  451. char* LANGSEL(char* name) {
  452.   unsigned long int adr=NULL;
  453.   if (NewLangStr)
  454.   if (!inthash_read(NewLangStr,name,(long int *)&adr))
  455.     adr=NULL;
  456.   if (adr) {
  457.     return (char*)adr;
  458.   }
  459.   return "";
  460. }
  461.  
  462. char* LANGINTKEY(char* name) {
  463.   unsigned long int adr=NULL;
  464.   if (NewLangStrKeys)
  465.   if (!inthash_read(NewLangStrKeys,name,(long int *)&adr))
  466.     adr=NULL;
  467.   if (adr) {
  468.     return (char*)adr;
  469.   }
  470.   return "";
  471. }
  472.  
  473.